home *** CD-ROM | disk | FTP | other *** search
/ Products & Services for NeXT / Products & Services for NeXT.iso / AlembicDemo.app / Axone / AddIn / nnetAddIn.m < prev    next >
Text File  |  1994-03-06  |  3KB  |  159 lines
  1. #import "nnet.h"
  2.  
  3. + (int)numFuncs
  4. {
  5.     /* une fonction par output */
  6.     return NB_OUTPUT ;
  7. }
  8.  
  9. + (char *)funcName:(int)functionNumber
  10. {
  11.     return fonction_name[functionNumber] ;
  12. }
  13.  
  14. - execute:(void *)stack numberOfParams:(int)num sheet:(void *)sh funcNumber:(int)fn
  15. {
  16.     AddInValue *tab_aiv1 ;
  17.     AddInValue *values ;
  18.     REAL    *input,*output ;
  19.     int    input_OK = TRUE ;
  20.     int    output_OK = TRUE ;
  21.     int    i,j ;
  22.     int    error ;
  23.     int    nb1,nb2 ;
  24.     int    err ;
  25.  
  26.     /* verification du nombre d’arguments */
  27.  
  28.     if (num != NB_INPUT)
  29.     {
  30.         pushErrorOnStack(stack,badFormulaError);
  31.         return self;
  32.     }
  33.  
  34.     /* allocation de la memoire pour la table tab_aiv1 */
  35.  
  36.     tab_aiv1 = (AddInValue *)calloc(NB_INPUT,sizeof(AddInValue)) ;
  37.     if (!tab_aiv1)
  38.     {
  39.         pushErrorOnStack(stack,badFormulaError);
  40.         return self;
  41.     }
  42.  
  43.     values = (AddInValue *)calloc(NB_INPUT,sizeof(AddInValue)) ;
  44.     if (!values)
  45.     {
  46.         free(tab_aiv1) ;
  47.         pushErrorOnStack(stack,badFormulaError);
  48.         return self;
  49.     }
  50.  
  51.     /* initialisation des structures AddInValue */
  52.  
  53.     for (i = 0 ; i < NB_INPUT ; i++)
  54.     {
  55.         initAddInValue(&tab_aiv1[i]) ;
  56.         initAddInValue(&values[i]) ;
  57.     }
  58.  
  59.     /* lecture des valeurs d’entrees dans l’ordre inverse */
  60.  
  61.     for (i = NB_INPUT - 1 ; i >= 0 ; i--)
  62.     {
  63.         popValueFromStack(stack,&tab_aiv1[i]) ;
  64.         getAddInValue(&tab_aiv1[i],&values[i],&error) ;
  65.         input_OK = input_OK && !error ;
  66.     }
  67.  
  68.     /* renvoie d’un message d’erreur en cas de pbs
  69.        et liberation de la memoire */
  70.  
  71.  
  72.     if (!input_OK)
  73.     {
  74.         fprintf(stderr,"erreur lors de la reccuperation des input\n") ;
  75.  
  76.         pushErrorOnStack(stack,badFormulaError);
  77.  
  78.         for (i = 0 ; i < NB_INPUT ; i++)
  79.         {
  80.             freeAddInValue(&tab_aiv1[i]) ;
  81.             freeAddInValue(&values[i]) ;
  82.         }
  83.  
  84.         free(tab_aiv1) ;
  85.         free(values) ;
  86.         return self;
  87.     }
  88.  
  89.  
  90.     /* allocation de la memoire pour les tables input et output */
  91.  
  92.     input = (REAL *)calloc(NB_INPUT,sizeof(REAL)) ;
  93.     if (!input)
  94.     {
  95.         pushErrorOnStack(stack,badFormulaError);
  96.  
  97.         for (i = 0 ; i < NB_INPUT ; i++)
  98.         {
  99.             freeAddInValue(&tab_aiv1[i]) ;
  100.             freeAddInValue(&values[i]) ;
  101.         }
  102.  
  103.         free(tab_aiv1) ;
  104.         free(values) ;
  105.  
  106.         return self;
  107.     }
  108.  
  109.     output = (REAL *)calloc(NB_OUTPUT,sizeof(REAL)) ;
  110.     if (!output)
  111.     {
  112.         pushErrorOnStack(stack,badFormulaError);
  113.  
  114.         for (i = 0 ; i < NB_INPUT ; i++)
  115.         {
  116.             freeAddInValue(&tab_aiv1[i]) ;
  117.             freeAddInValue(&values[i]) ;
  118.         }
  119.  
  120.         free(tab_aiv1) ;
  121.         free(values) ;
  122.  
  123.         free(input) ;
  124.  
  125.         return self;
  126.     }
  127.  
  128.     /* extraction des donnees dans la table input */
  129.  
  130.     for ( i = 0 ; i < NB_INPUT ; i++)
  131.     {
  132.  
  133.         input[i] = getAddInValueNumber(&values[i],&error) ;
  134.  
  135.         freeAddInValue(&tab_aiv1[i]) ;
  136.         freeAddInValue(&values[i]) ;
  137.     }
  138.  
  139.     free(tab_aiv1) ;
  140.     free(values) ;
  141.  
  142.     /* execution d’une propagation */
  143.  
  144.     run(&net,input,output,stats_input,stats_output) ;
  145.  
  146.     if (fn < NB_OUTPUT)
  147.     {
  148.         pushNumberOnStack(stack,output[fn]) ;
  149.     }
  150.     else
  151.     {
  152.         pushErrorOnStack(stack,badFormulaError);
  153.     }
  154.  
  155.     free(input) ;
  156.     free(output) ;
  157.  
  158.     return self ;
  159. }